package com.tjbank.cssys.mybatis.sqlbuilder;

import com.tansun.web.framework.dao.SQLBulider;

import java.io.Serializable;

/**
 * IamSequenceSqlBuilder
 * 
 * @author PG(Auto Generator)
 * @version V2.0
 */
public class IamSequenceSqlBuilder extends SQLBulider<IamSequenceSqlBuilder> implements Serializable {
    private static final long serialVersionUID = -161123581321345589L;

    public IamSequenceSqlBuilder() {
        _id = this.toString().split("@")[1];
    }

    public IamSequenceSqlBuilder andIdEqualTo(Integer value) {
        return addAndCriterion("id", Operator.EqualTo, value);
    }

    public IamSequenceSqlBuilder andIdNotEqualTo(Integer value) {
        return addAndCriterion("id", Operator.NotEqualTo, value);
    }

    public IamSequenceSqlBuilder andIdGreaterThan(Integer value) {
        return addAndCriterion("id", Operator.GreaterThan, value);
    }

    public IamSequenceSqlBuilder andIdGreaterThanOrEqualTo(Integer value) {
        return addAndCriterion("id", Operator.GreaterThanOrEqualTo, value);
    }

    public IamSequenceSqlBuilder andIdLessThan(Integer value) {
        return addAndCriterion("id", Operator.LessThan, value);
    }

    public IamSequenceSqlBuilder andIdLessThanOrEqualTo(Integer value) {
        return addAndCriterion("id", Operator.LessThanOrEqualTo, value);
    }

    public IamSequenceSqlBuilder andIdIsNull() {
        return addAndCriterion("id", Operator.IsNull, null);
    }

    public IamSequenceSqlBuilder andIdIsNotNull() {
        return addAndCriterion("id", Operator.IsNotNull, null);
    }

    public IamSequenceSqlBuilder andIdLikeBoth(Integer value) {
        return addAndCriterion("id", Operator.Like, likeMark + value + likeMark);
    }

    public IamSequenceSqlBuilder andIdLikeLeft(Integer value) {
        return addAndCriterion("id", Operator.Like, likeMark + value);
    }

    public IamSequenceSqlBuilder andIdLikeRigth(Integer value) {
        return addAndCriterion("id", Operator.Like, value + likeMark);
    }

    public IamSequenceSqlBuilder andIdNotLikeBoth(Integer value) {
        return addAndCriterion("id", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamSequenceSqlBuilder andIdNotLikeLeft(Integer value) {
        return addAndCriterion("id", Operator.NotLike, likeMark + value);
    }

    public IamSequenceSqlBuilder andIdNotLikeRigth(Integer value) {
        return addAndCriterion("id", Operator.NotLike, value + likeMark);
    }

    public IamSequenceSqlBuilder orIdEqualTo(Integer value) {
        return addOrCriterion("id", Operator.EqualTo, value);
    }

    public IamSequenceSqlBuilder orIdNotEqualTo(Integer value) {
        return addOrCriterion("id", Operator.NotEqualTo, value);
    }

    public IamSequenceSqlBuilder orIdGreaterThan(Integer value) {
        return addOrCriterion("id", Operator.GreaterThan, value);
    }

    public IamSequenceSqlBuilder orIdGreaterThanOrEqualTo(Integer value) {
        return addOrCriterion("id", Operator.GreaterThanOrEqualTo, value);
    }

    public IamSequenceSqlBuilder orIdLessThan(Integer value) {
        return addOrCriterion("id", Operator.LessThan, value);
    }

    public IamSequenceSqlBuilder orIdLessThanOrEqualTo(Integer value) {
        return addOrCriterion("id", Operator.LessThanOrEqualTo, value);
    }

    public IamSequenceSqlBuilder orIdIsNull() {
        return addOrCriterion("id", Operator.IsNull, null);
    }

    public IamSequenceSqlBuilder orIdIsNotNull() {
        return addOrCriterion("id", Operator.IsNotNull, null);
    }

    public IamSequenceSqlBuilder orIdLikeBoth(Integer value) {
        return addOrCriterion("id", Operator.Like, likeMark + value + likeMark);
    }

    public IamSequenceSqlBuilder orIdLikeLeft(Integer value) {
        return addOrCriterion("id", Operator.Like, likeMark + value);
    }

    public IamSequenceSqlBuilder orIdLikeRigth(Integer value) {
        return addOrCriterion("id", Operator.Like, value + likeMark);
    }

    public IamSequenceSqlBuilder orIdNotLikeBoth(Integer value) {
        return addOrCriterion("id", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamSequenceSqlBuilder orIdNotLikeLeft(Integer value) {
        return addOrCriterion("id", Operator.NotLike, likeMark + value);
    }

    public IamSequenceSqlBuilder orIdNotLikeRigth(Integer value) {
        return addOrCriterion("id", Operator.NotLike, value + likeMark);
    }

    public IamSequenceSqlBuilder orderById(boolean isDesc) {
        return addOrderBy("id", isDesc);
    }

    public IamSequenceSqlBuilder andCurrvalEqualTo(Integer value) {
        return addAndCriterion("currval", Operator.EqualTo, value);
    }

    public IamSequenceSqlBuilder andCurrvalNotEqualTo(Integer value) {
        return addAndCriterion("currval", Operator.NotEqualTo, value);
    }

    public IamSequenceSqlBuilder andCurrvalGreaterThan(Integer value) {
        return addAndCriterion("currval", Operator.GreaterThan, value);
    }

    public IamSequenceSqlBuilder andCurrvalGreaterThanOrEqualTo(Integer value) {
        return addAndCriterion("currval", Operator.GreaterThanOrEqualTo, value);
    }

    public IamSequenceSqlBuilder andCurrvalLessThan(Integer value) {
        return addAndCriterion("currval", Operator.LessThan, value);
    }

    public IamSequenceSqlBuilder andCurrvalLessThanOrEqualTo(Integer value) {
        return addAndCriterion("currval", Operator.LessThanOrEqualTo, value);
    }

    public IamSequenceSqlBuilder andCurrvalIsNull() {
        return addAndCriterion("currval", Operator.IsNull, null);
    }

    public IamSequenceSqlBuilder andCurrvalIsNotNull() {
        return addAndCriterion("currval", Operator.IsNotNull, null);
    }

    public IamSequenceSqlBuilder andCurrvalLikeBoth(Integer value) {
        return addAndCriterion("currval", Operator.Like, likeMark + value + likeMark);
    }

    public IamSequenceSqlBuilder andCurrvalLikeLeft(Integer value) {
        return addAndCriterion("currval", Operator.Like, likeMark + value);
    }

    public IamSequenceSqlBuilder andCurrvalLikeRigth(Integer value) {
        return addAndCriterion("currval", Operator.Like, value + likeMark);
    }

    public IamSequenceSqlBuilder andCurrvalNotLikeBoth(Integer value) {
        return addAndCriterion("currval", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamSequenceSqlBuilder andCurrvalNotLikeLeft(Integer value) {
        return addAndCriterion("currval", Operator.NotLike, likeMark + value);
    }

    public IamSequenceSqlBuilder andCurrvalNotLikeRigth(Integer value) {
        return addAndCriterion("currval", Operator.NotLike, value + likeMark);
    }

    public IamSequenceSqlBuilder orCurrvalEqualTo(Integer value) {
        return addOrCriterion("currval", Operator.EqualTo, value);
    }

    public IamSequenceSqlBuilder orCurrvalNotEqualTo(Integer value) {
        return addOrCriterion("currval", Operator.NotEqualTo, value);
    }

    public IamSequenceSqlBuilder orCurrvalGreaterThan(Integer value) {
        return addOrCriterion("currval", Operator.GreaterThan, value);
    }

    public IamSequenceSqlBuilder orCurrvalGreaterThanOrEqualTo(Integer value) {
        return addOrCriterion("currval", Operator.GreaterThanOrEqualTo, value);
    }

    public IamSequenceSqlBuilder orCurrvalLessThan(Integer value) {
        return addOrCriterion("currval", Operator.LessThan, value);
    }

    public IamSequenceSqlBuilder orCurrvalLessThanOrEqualTo(Integer value) {
        return addOrCriterion("currval", Operator.LessThanOrEqualTo, value);
    }

    public IamSequenceSqlBuilder orCurrvalIsNull() {
        return addOrCriterion("currval", Operator.IsNull, null);
    }

    public IamSequenceSqlBuilder orCurrvalIsNotNull() {
        return addOrCriterion("currval", Operator.IsNotNull, null);
    }

    public IamSequenceSqlBuilder orCurrvalLikeBoth(Integer value) {
        return addOrCriterion("currval", Operator.Like, likeMark + value + likeMark);
    }

    public IamSequenceSqlBuilder orCurrvalLikeLeft(Integer value) {
        return addOrCriterion("currval", Operator.Like, likeMark + value);
    }

    public IamSequenceSqlBuilder orCurrvalLikeRigth(Integer value) {
        return addOrCriterion("currval", Operator.Like, value + likeMark);
    }

    public IamSequenceSqlBuilder orCurrvalNotLikeBoth(Integer value) {
        return addOrCriterion("currval", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamSequenceSqlBuilder orCurrvalNotLikeLeft(Integer value) {
        return addOrCriterion("currval", Operator.NotLike, likeMark + value);
    }

    public IamSequenceSqlBuilder orCurrvalNotLikeRigth(Integer value) {
        return addOrCriterion("currval", Operator.NotLike, value + likeMark);
    }

    public IamSequenceSqlBuilder orderByCurrval(boolean isDesc) {
        return addOrderBy("currval", isDesc);
    }

    public IamSequenceSqlBuilder andIncrementEqualTo(Integer value) {
        return addAndCriterion("increment", Operator.EqualTo, value);
    }

    public IamSequenceSqlBuilder andIncrementNotEqualTo(Integer value) {
        return addAndCriterion("increment", Operator.NotEqualTo, value);
    }

    public IamSequenceSqlBuilder andIncrementGreaterThan(Integer value) {
        return addAndCriterion("increment", Operator.GreaterThan, value);
    }

    public IamSequenceSqlBuilder andIncrementGreaterThanOrEqualTo(Integer value) {
        return addAndCriterion("increment", Operator.GreaterThanOrEqualTo, value);
    }

    public IamSequenceSqlBuilder andIncrementLessThan(Integer value) {
        return addAndCriterion("increment", Operator.LessThan, value);
    }

    public IamSequenceSqlBuilder andIncrementLessThanOrEqualTo(Integer value) {
        return addAndCriterion("increment", Operator.LessThanOrEqualTo, value);
    }

    public IamSequenceSqlBuilder andIncrementIsNull() {
        return addAndCriterion("increment", Operator.IsNull, null);
    }

    public IamSequenceSqlBuilder andIncrementIsNotNull() {
        return addAndCriterion("increment", Operator.IsNotNull, null);
    }

    public IamSequenceSqlBuilder andIncrementLikeBoth(Integer value) {
        return addAndCriterion("increment", Operator.Like, likeMark + value + likeMark);
    }

    public IamSequenceSqlBuilder andIncrementLikeLeft(Integer value) {
        return addAndCriterion("increment", Operator.Like, likeMark + value);
    }

    public IamSequenceSqlBuilder andIncrementLikeRigth(Integer value) {
        return addAndCriterion("increment", Operator.Like, value + likeMark);
    }

    public IamSequenceSqlBuilder andIncrementNotLikeBoth(Integer value) {
        return addAndCriterion("increment", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamSequenceSqlBuilder andIncrementNotLikeLeft(Integer value) {
        return addAndCriterion("increment", Operator.NotLike, likeMark + value);
    }

    public IamSequenceSqlBuilder andIncrementNotLikeRigth(Integer value) {
        return addAndCriterion("increment", Operator.NotLike, value + likeMark);
    }

    public IamSequenceSqlBuilder orIncrementEqualTo(Integer value) {
        return addOrCriterion("increment", Operator.EqualTo, value);
    }

    public IamSequenceSqlBuilder orIncrementNotEqualTo(Integer value) {
        return addOrCriterion("increment", Operator.NotEqualTo, value);
    }

    public IamSequenceSqlBuilder orIncrementGreaterThan(Integer value) {
        return addOrCriterion("increment", Operator.GreaterThan, value);
    }

    public IamSequenceSqlBuilder orIncrementGreaterThanOrEqualTo(Integer value) {
        return addOrCriterion("increment", Operator.GreaterThanOrEqualTo, value);
    }

    public IamSequenceSqlBuilder orIncrementLessThan(Integer value) {
        return addOrCriterion("increment", Operator.LessThan, value);
    }

    public IamSequenceSqlBuilder orIncrementLessThanOrEqualTo(Integer value) {
        return addOrCriterion("increment", Operator.LessThanOrEqualTo, value);
    }

    public IamSequenceSqlBuilder orIncrementIsNull() {
        return addOrCriterion("increment", Operator.IsNull, null);
    }

    public IamSequenceSqlBuilder orIncrementIsNotNull() {
        return addOrCriterion("increment", Operator.IsNotNull, null);
    }

    public IamSequenceSqlBuilder orIncrementLikeBoth(Integer value) {
        return addOrCriterion("increment", Operator.Like, likeMark + value + likeMark);
    }

    public IamSequenceSqlBuilder orIncrementLikeLeft(Integer value) {
        return addOrCriterion("increment", Operator.Like, likeMark + value);
    }

    public IamSequenceSqlBuilder orIncrementLikeRigth(Integer value) {
        return addOrCriterion("increment", Operator.Like, value + likeMark);
    }

    public IamSequenceSqlBuilder orIncrementNotLikeBoth(Integer value) {
        return addOrCriterion("increment", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamSequenceSqlBuilder orIncrementNotLikeLeft(Integer value) {
        return addOrCriterion("increment", Operator.NotLike, likeMark + value);
    }

    public IamSequenceSqlBuilder orIncrementNotLikeRigth(Integer value) {
        return addOrCriterion("increment", Operator.NotLike, value + likeMark);
    }

    public IamSequenceSqlBuilder orderByIncrement(boolean isDesc) {
        return addOrderBy("increment", isDesc);
    }

    public IamSequenceSqlBuilder andPrefixEqualTo(String value) {
        return addAndCriterion("prefix", Operator.EqualTo, value);
    }

    public IamSequenceSqlBuilder andPrefixNotEqualTo(String value) {
        return addAndCriterion("prefix", Operator.NotEqualTo, value);
    }

    public IamSequenceSqlBuilder andPrefixGreaterThan(String value) {
        return addAndCriterion("prefix", Operator.GreaterThan, value);
    }

    public IamSequenceSqlBuilder andPrefixGreaterThanOrEqualTo(String value) {
        return addAndCriterion("prefix", Operator.GreaterThanOrEqualTo, value);
    }

    public IamSequenceSqlBuilder andPrefixLessThan(String value) {
        return addAndCriterion("prefix", Operator.LessThan, value);
    }

    public IamSequenceSqlBuilder andPrefixLessThanOrEqualTo(String value) {
        return addAndCriterion("prefix", Operator.LessThanOrEqualTo, value);
    }

    public IamSequenceSqlBuilder andPrefixIsNull() {
        return addAndCriterion("prefix", Operator.IsNull, null);
    }

    public IamSequenceSqlBuilder andPrefixIsNotNull() {
        return addAndCriterion("prefix", Operator.IsNotNull, null);
    }

    public IamSequenceSqlBuilder andPrefixLikeBoth(String value) {
        return addAndCriterion("prefix", Operator.Like, likeMark + value + likeMark);
    }

    public IamSequenceSqlBuilder andPrefixLikeLeft(String value) {
        return addAndCriterion("prefix", Operator.Like, likeMark + value);
    }

    public IamSequenceSqlBuilder andPrefixLikeRigth(String value) {
        return addAndCriterion("prefix", Operator.Like, value + likeMark);
    }

    public IamSequenceSqlBuilder andPrefixNotLikeBoth(String value) {
        return addAndCriterion("prefix", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamSequenceSqlBuilder andPrefixNotLikeLeft(String value) {
        return addAndCriterion("prefix", Operator.NotLike, likeMark + value);
    }

    public IamSequenceSqlBuilder andPrefixNotLikeRigth(String value) {
        return addAndCriterion("prefix", Operator.NotLike, value + likeMark);
    }

    public IamSequenceSqlBuilder orPrefixEqualTo(String value) {
        return addOrCriterion("prefix", Operator.EqualTo, value);
    }

    public IamSequenceSqlBuilder orPrefixNotEqualTo(String value) {
        return addOrCriterion("prefix", Operator.NotEqualTo, value);
    }

    public IamSequenceSqlBuilder orPrefixGreaterThan(String value) {
        return addOrCriterion("prefix", Operator.GreaterThan, value);
    }

    public IamSequenceSqlBuilder orPrefixGreaterThanOrEqualTo(String value) {
        return addOrCriterion("prefix", Operator.GreaterThanOrEqualTo, value);
    }

    public IamSequenceSqlBuilder orPrefixLessThan(String value) {
        return addOrCriterion("prefix", Operator.LessThan, value);
    }

    public IamSequenceSqlBuilder orPrefixLessThanOrEqualTo(String value) {
        return addOrCriterion("prefix", Operator.LessThanOrEqualTo, value);
    }

    public IamSequenceSqlBuilder orPrefixIsNull() {
        return addOrCriterion("prefix", Operator.IsNull, null);
    }

    public IamSequenceSqlBuilder orPrefixIsNotNull() {
        return addOrCriterion("prefix", Operator.IsNotNull, null);
    }

    public IamSequenceSqlBuilder orPrefixLikeBoth(String value) {
        return addOrCriterion("prefix", Operator.Like, likeMark + value + likeMark);
    }

    public IamSequenceSqlBuilder orPrefixLikeLeft(String value) {
        return addOrCriterion("prefix", Operator.Like, likeMark + value);
    }

    public IamSequenceSqlBuilder orPrefixLikeRigth(String value) {
        return addOrCriterion("prefix", Operator.Like, value + likeMark);
    }

    public IamSequenceSqlBuilder orPrefixNotLikeBoth(String value) {
        return addOrCriterion("prefix", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamSequenceSqlBuilder orPrefixNotLikeLeft(String value) {
        return addOrCriterion("prefix", Operator.NotLike, likeMark + value);
    }

    public IamSequenceSqlBuilder orPrefixNotLikeRigth(String value) {
        return addOrCriterion("prefix", Operator.NotLike, value + likeMark);
    }

    public IamSequenceSqlBuilder orderByPrefix(boolean isDesc) {
        return addOrderBy("prefix", isDesc);
    }

    public IamSequenceSqlBuilder andDigitcapacityEqualTo(Integer value) {
        return addAndCriterion("digitcapacity", Operator.EqualTo, value);
    }

    public IamSequenceSqlBuilder andDigitcapacityNotEqualTo(Integer value) {
        return addAndCriterion("digitcapacity", Operator.NotEqualTo, value);
    }

    public IamSequenceSqlBuilder andDigitcapacityGreaterThan(Integer value) {
        return addAndCriterion("digitcapacity", Operator.GreaterThan, value);
    }

    public IamSequenceSqlBuilder andDigitcapacityGreaterThanOrEqualTo(Integer value) {
        return addAndCriterion("digitcapacity", Operator.GreaterThanOrEqualTo, value);
    }

    public IamSequenceSqlBuilder andDigitcapacityLessThan(Integer value) {
        return addAndCriterion("digitcapacity", Operator.LessThan, value);
    }

    public IamSequenceSqlBuilder andDigitcapacityLessThanOrEqualTo(Integer value) {
        return addAndCriterion("digitcapacity", Operator.LessThanOrEqualTo, value);
    }

    public IamSequenceSqlBuilder andDigitcapacityIsNull() {
        return addAndCriterion("digitcapacity", Operator.IsNull, null);
    }

    public IamSequenceSqlBuilder andDigitcapacityIsNotNull() {
        return addAndCriterion("digitcapacity", Operator.IsNotNull, null);
    }

    public IamSequenceSqlBuilder andDigitcapacityLikeBoth(Integer value) {
        return addAndCriterion("digitcapacity", Operator.Like, likeMark + value + likeMark);
    }

    public IamSequenceSqlBuilder andDigitcapacityLikeLeft(Integer value) {
        return addAndCriterion("digitcapacity", Operator.Like, likeMark + value);
    }

    public IamSequenceSqlBuilder andDigitcapacityLikeRigth(Integer value) {
        return addAndCriterion("digitcapacity", Operator.Like, value + likeMark);
    }

    public IamSequenceSqlBuilder andDigitcapacityNotLikeBoth(Integer value) {
        return addAndCriterion("digitcapacity", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamSequenceSqlBuilder andDigitcapacityNotLikeLeft(Integer value) {
        return addAndCriterion("digitcapacity", Operator.NotLike, likeMark + value);
    }

    public IamSequenceSqlBuilder andDigitcapacityNotLikeRigth(Integer value) {
        return addAndCriterion("digitcapacity", Operator.NotLike, value + likeMark);
    }

    public IamSequenceSqlBuilder orDigitcapacityEqualTo(Integer value) {
        return addOrCriterion("digitcapacity", Operator.EqualTo, value);
    }

    public IamSequenceSqlBuilder orDigitcapacityNotEqualTo(Integer value) {
        return addOrCriterion("digitcapacity", Operator.NotEqualTo, value);
    }

    public IamSequenceSqlBuilder orDigitcapacityGreaterThan(Integer value) {
        return addOrCriterion("digitcapacity", Operator.GreaterThan, value);
    }

    public IamSequenceSqlBuilder orDigitcapacityGreaterThanOrEqualTo(Integer value) {
        return addOrCriterion("digitcapacity", Operator.GreaterThanOrEqualTo, value);
    }

    public IamSequenceSqlBuilder orDigitcapacityLessThan(Integer value) {
        return addOrCriterion("digitcapacity", Operator.LessThan, value);
    }

    public IamSequenceSqlBuilder orDigitcapacityLessThanOrEqualTo(Integer value) {
        return addOrCriterion("digitcapacity", Operator.LessThanOrEqualTo, value);
    }

    public IamSequenceSqlBuilder orDigitcapacityIsNull() {
        return addOrCriterion("digitcapacity", Operator.IsNull, null);
    }

    public IamSequenceSqlBuilder orDigitcapacityIsNotNull() {
        return addOrCriterion("digitcapacity", Operator.IsNotNull, null);
    }

    public IamSequenceSqlBuilder orDigitcapacityLikeBoth(Integer value) {
        return addOrCriterion("digitcapacity", Operator.Like, likeMark + value + likeMark);
    }

    public IamSequenceSqlBuilder orDigitcapacityLikeLeft(Integer value) {
        return addOrCriterion("digitcapacity", Operator.Like, likeMark + value);
    }

    public IamSequenceSqlBuilder orDigitcapacityLikeRigth(Integer value) {
        return addOrCriterion("digitcapacity", Operator.Like, value + likeMark);
    }

    public IamSequenceSqlBuilder orDigitcapacityNotLikeBoth(Integer value) {
        return addOrCriterion("digitcapacity", Operator.NotLike, likeMark + value + likeMark);
    }

    public IamSequenceSqlBuilder orDigitcapacityNotLikeLeft(Integer value) {
        return addOrCriterion("digitcapacity", Operator.NotLike, likeMark + value);
    }

    public IamSequenceSqlBuilder orDigitcapacityNotLikeRigth(Integer value) {
        return addOrCriterion("digitcapacity", Operator.NotLike, value + likeMark);
    }

    public IamSequenceSqlBuilder orderByDigitcapacity(boolean isDesc) {
        return addOrderBy("digitcapacity", isDesc);
    }
}